import types

# imports
import pytest
from matplotlib._api.__init__ import caching_module_getattr

# unit tests


# Helper function to simulate module-level __getattr__ usage
def make_module_with_getattr_class(properties):
    """
    Dynamically create a module with a decorated __getattr__ using the given property dict.
    properties: dict of {name: function returning value}
    Returns: (module, getattr_func, class_type)
    """
    # Build the class dict with properties
    class_dict = {}
    for name, func in properties.items():
        class_dict[name] = property(func)
    # Dynamically create the class
    getattr_class = type("__getattr__", (), class_dict)
    # Decorate with caching_module_getattr
    codeflash_output = caching_module_getattr(getattr_class)
    getattr_func = codeflash_output
    # Create a dummy module to simulate module-level getattr
    module = types.ModuleType("dummy_module")
    module.__getattr__ = getattr_func
    return module, getattr_func, getattr_class


# ----------------
# Basic Test Cases
# ----------------


def test_single_property_access():
    # Test that a single property is accessible and returns the correct value.
    module, getattr_func, _ = make_module_with_getattr_class({"foo": lambda self: 42})


def test_multiple_properties_access():
    # Test that multiple properties are accessible and return correct values.
    module, getattr_func, _ = make_module_with_getattr_class(
        {"foo": lambda self: 1, "bar": lambda self: 2, "baz": lambda self: 3}
    )


def test_attribute_error_on_missing_property():
    # Test that AttributeError is raised for missing property.
    module, getattr_func, getattr_class = make_module_with_getattr_class(
        {"foo": lambda self: 1}
    )
    with pytest.raises(AttributeError) as excinfo:
        module.__getattr__("bar")
    # Also test direct getattr_func
    with pytest.raises(AttributeError):
        getattr_func("baz")


def test_property_is_cached():
    # Test that property is only called once (caching).
    call_count = {"count": 0}

    def foo(self):
        call_count["count"] += 1
        return 99

    module, getattr_func, _ = make_module_with_getattr_class({"foo": foo})


def test_class_name_must_be_dunder_getattr():
    # Test that using a class with a wrong name raises AssertionError.
    class NotGetAttr:
        @property
        def foo(self):
            return 1

    with pytest.raises(AssertionError):
        caching_module_getattr(NotGetAttr)  # 1.34μs -> 1.29μs (3.63% faster)


# ---------------
# Edge Test Cases
# ---------------


def test_property_with_side_effects():
    # Test that side effects only happen once due to caching.
    side_effect = {"val": 0}

    def foo(self):
        side_effect["val"] += 10
        return side_effect["val"]

    module, getattr_func, _ = make_module_with_getattr_class({"foo": foo})


def test_non_property_attributes_are_ignored():
    # Test that only properties are exposed, not other attributes.
    def foo(self):
        return 123

    class_dict = {"foo": foo, "bar": 456}
    getattr_class = type("__getattr__", (), class_dict)
    codeflash_output = caching_module_getattr(getattr_class)
    getattr_func = codeflash_output  # 8.70μs -> 7.88μs (10.4% faster)
    # Only foo is a method, not a property, so nothing should be exposed
    with pytest.raises(AttributeError):
        getattr_func("foo")
    with pytest.raises(AttributeError):
        getattr_func("bar")


def test_property_named_dunder_is_ignored():
    # Dunder-named properties should be accessible if present.
    def __weird__(self):
        return 77

    module, getattr_func, _ = make_module_with_getattr_class({"__weird__": __weird__})


def test_property_returns_none():
    # Test that a property returning None works.
    module, getattr_func, _ = make_module_with_getattr_class({"foo": lambda self: None})


def test_property_with_exception():
    # Test that if property raises, the exception is propagated.
    def foo(self):
        raise ValueError("fail!")

    module, getattr_func, _ = make_module_with_getattr_class({"foo": foo})
    with pytest.raises(ValueError):
        module.__getattr__("foo")


def test_module_name_in_error_message():
    # The AttributeError should mention the module name.
    module, getattr_func, getattr_class = make_module_with_getattr_class(
        {"foo": lambda self: 1}
    )
    try:
        module.__getattr__("notfound")
    except AttributeError as e:
        pass


def test_property_with_name_similar_to_method():
    # Property with same name as method should be accessible.
    def foo(self):
        return "property"

    class_dict = {"foo": property(foo), "foo_method": lambda self: "method"}
    getattr_class = type("__getattr__", (), class_dict)
    codeflash_output = caching_module_getattr(getattr_class)
    getattr_func = codeflash_output  # 8.73μs -> 8.10μs (7.87% faster)
    with pytest.raises(AttributeError):
        getattr_func("foo_method")


# ----------------------
# Large Scale Test Cases
# ----------------------


def test_many_properties():
    # Test with a large number of properties (up to 1000).
    N = 1000

    def make_prop(i):
        return lambda self, val=i: val

    properties = {f"prop_{i}": make_prop(i) for i in range(N)}
    module, getattr_func, _ = make_module_with_getattr_class(properties)
    # Access all and check values
    for i in range(N):
        pass


def test_caching_with_many_properties():
    # Test that caching works with many properties, only one call per property.
    N = 100
    call_counts = [0] * N

    def make_prop(i):
        def prop(self):
            call_counts[i] += 1
            return i * 2

        return prop

    properties = {f"p{i}": make_prop(i) for i in range(N)}
    module, getattr_func, _ = make_module_with_getattr_class(properties)
    # Access each property twice
    for i in range(N):
        pass


def test_attribute_error_for_all_missing_in_large():
    # Test that missing properties always raise AttributeError, even in large class.
    N = 300
    properties = {f"x{i}": (lambda self, val=i: val) for i in range(N)}
    module, getattr_func, getattr_class = make_module_with_getattr_class(properties)
    for i in range(N, N + 10):
        with pytest.raises(AttributeError):
            module.__getattr__(f"x{i}")


def test_performance_with_many_accesses():
    # Test that repeated accesses are fast (caching), but don't actually time it.
    # Instead, test that the property is only called once per property.
    N = 200
    call_counts = [0] * N

    def make_prop(i):
        def prop(self):
            call_counts[i] += 1
            return i

        return prop

    properties = {f"xx{i}": make_prop(i) for i in range(N)}
    module, getattr_func, _ = make_module_with_getattr_class(properties)
    for _ in range(5):  # Access each property 5 times
        for i in range(N):
            pass


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import types

# imports
import pytest
from matplotlib._api.__init__ import caching_module_getattr

# unit tests

# --------- BASIC TEST CASES ---------


def test_single_property_access():
    # Test that a single property is accessible and returns the correct value.
    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            return 42


def test_multiple_properties_access():
    # Test that multiple properties are accessible and return correct values.
    @caching_module_getattr
    class __getattr__:
        @property
        def alpha(self):
            return "A"

        @property
        def beta(self):
            return "B"

        @property
        def gamma(self):
            return "G"


def test_attribute_error_on_missing_property():
    # Test that AttributeError is raised with correct message for missing property.
    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            return 1

    with pytest.raises(AttributeError) as excinfo:
        __getattr__("bar")


def test_properties_are_cached():
    # Test that property is only computed once (caching behavior).
    call_counter = {"count": 0}

    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            call_counter["count"] += 1
            return 99


def test_only_properties_are_exposed():
    # Test that only @property attributes are accessible.
    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            return 1

        def bar(self):  # Not a property
            return 2

        baz = 3  # Not a property

    with pytest.raises(AttributeError):
        __getattr__("bar")
    with pytest.raises(AttributeError):
        __getattr__("baz")


# --------- EDGE TEST CASES ---------


def test_class_name_must_be_dunder_getattr():
    # Test that using a class with wrong name raises AssertionError.
    with pytest.raises(AssertionError):

        @caching_module_getattr
        class NotGetattr:
            @property
            def foo(self):
                return 1


def test_property_returning_none():
    # Test that property returning None is handled and cached.
    call_counter = {"count": 0}

    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            call_counter["count"] += 1
            return None


def test_property_with_side_effects():
    # Test that side effects only occur once due to caching.
    side_effects = []

    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            side_effects.append("called")
            return "bar"


def test_attribute_error_message_content():
    # Test that AttributeError message includes module name and attribute.
    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            return 1

    try:
        __getattr__("missing")
    except AttributeError as e:
        msg = str(e)


def test_property_with_exception():
    # Test that if property raises, the exception is propagated.
    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            raise ValueError("fail")

    with pytest.raises(ValueError):
        __getattr__("foo")


def test_module_level_usage_simulation():
    # Simulate usage as module-level __getattr__.
    module = types.ModuleType("mod")

    @caching_module_getattr
    class __getattr__:
        @property
        def foo(self):
            return 1

    module.__getattr__ = __getattr__
    with pytest.raises(AttributeError):
        module.__getattr__("bar")


# --------- LARGE SCALE TEST CASES ---------


def test_many_properties():
    # Test with a large number of properties.
    N = 500
    values = list(range(N))

    def make_property(i):
        return property(lambda self, v=i: v)

    props = {"prop_%d" % i: make_property(i) for i in range(N)}
    __getattr__ = type("__getattr__", (), props)
    codeflash_output = caching_module_getattr(__getattr__)
    __getattr__ = codeflash_output  # 40.1μs -> 39.0μs (2.91% faster)

    # All should be accessible and correct
    for i in range(N):
        pass

    # Missing property
    with pytest.raises(AttributeError):
        __getattr__("prop_%d" % N)


def test_caching_with_many_properties():
    # Test that caching works with many properties and only one call per property.
    N = 200
    call_counts = [0] * N

    def make_property(i):
        def getter(self):
            call_counts[i] += 1
            return i

        return property(getter)

    props = {"p%d" % i: make_property(i) for i in range(N)}
    __getattr__ = type("__getattr__", (), props)
    codeflash_output = caching_module_getattr(__getattr__)
    __getattr__ = codeflash_output  # 23.3μs -> 22.3μs (4.37% faster)

    for i in range(N):
        pass


def test_large_scale_attribute_error():
    # Test that AttributeError is still correct with many properties.
    N = 100
    props = {"a%d" % i: property(lambda self, v=i: v) for i in range(N)}
    __getattr__ = type("__getattr__", (), props)
    codeflash_output = caching_module_getattr(__getattr__)
    __getattr__ = codeflash_output  # 16.0μs -> 15.0μs (6.60% faster)

    with pytest.raises(AttributeError):
        __getattr__("not_present")


def test_large_scale_random_access():
    # Test random access order to properties.
    import random

    N = 300
    values = list(range(N))
    random.shuffle(values)
    props = {"x%d" % v: property(lambda self, val=v: val) for v in values}
    __getattr__ = type("__getattr__", (), props)
    codeflash_output = caching_module_getattr(__getattr__)
    __getattr__ = codeflash_output  # 27.8μs -> 26.4μs (5.35% faster)

    for v in values:
        pass
    for v in values:
        pass


def test_large_scale_property_with_side_effects():
    # Test that side effect for each property only occurs once with many properties.
    N = 100
    calls = [0] * N

    def make_property(i):
        def getter(self):
            calls[i] += 1
            return i

        return property(getter)

    props = {"y%d" % i: make_property(i) for i in range(N)}
    __getattr__ = type("__getattr__", (), props)
    codeflash_output = caching_module_getattr(__getattr__)
    __getattr__ = codeflash_output  # 16.9μs -> 15.6μs (8.55% faster)

    for i in range(N):
        pass


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.